package mediatheque.model;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;

import tools.ComboItem;

public class MediathequeModel extends AbstractModel{
	
	private static final long serialVersionUID = 2327273757955294625L;
	private Hashtable<String,GestionnaireModel> listeGestionnaires ;
	private Hashtable<String,PretModel> listePrets;
	private Hashtable<String,DocumentModel> listeDocuments;
	private Hashtable<String,EmprunteurModel> listeEmprunteurs;

	public static final int DOCUMENT = 0;
	public static final int GESTIONNAIRE = 1;
	public static final int PRET = 2;
	public static final int EMPRUNTEUR = 3;
	
	public MediathequeModel() {
		listeGestionnaires = new Hashtable<String, GestionnaireModel>();
		listePrets = new Hashtable<String, PretModel>();
		listeDocuments = new Hashtable<String, DocumentModel>();
		listeEmprunteurs = new Hashtable<String, EmprunteurModel>();
	}
	
	public static MediathequeModel creerBaseDeDonneeVierge(){
		MediathequeModel mediaModel = new MediathequeModel();
    	GestionnaireModel gm = new GestionnaireModel("admin", "admin", "Administrateur", "", "", "");
    	mediaModel.ajouterGestionnaire(gm.getIdentifiant(), gm);
    	return mediaModel;
	}
	
	/* Documents */
	public Hashtable<String, DocumentModel> getListeDocuments(){
		return listeDocuments;
	}
	public void setListeDocuments(Hashtable<String, DocumentModel> doc){
		listeDocuments = doc;
	}
	
	public DocumentModel getDocument(String identifiant) {
		return listeDocuments.get(identifiant);
	}
	public Collection<DocumentModel> getDocuments() {
		return listeDocuments.values();
	}
	public void ajouterDocument(String identifiant, DocumentModel doc) {
		if (!listeDocuments.containsKey(identifiant)) {
			listeDocuments.put(identifiant, doc);
			setChanged();
			notifyObservers(DOCUMENT);
		}
	}
	public void supprimerDocument(String identifiant) {
		if (listeDocuments.containsKey(identifiant)) {
			listeDocuments.remove(identifiant);
			setChanged();
			notifyObservers(DOCUMENT);
		}
	}

	public Collection<DocumentModel> getDocumentAvecNom(String nom){
		List<DocumentModel> tmp = new ArrayList<DocumentModel>();
		for (DocumentModel doc : listeDocuments.values()) {
			if(doc.getNom().toLowerCase().contains(nom.toLowerCase())) tmp.add(doc);
		}
		return tmp;
	}
	
	public Collection<DocumentModel> getDocumentAvecIdentifiant(String identifiant){
		List<DocumentModel> tmp = new ArrayList<DocumentModel>();
		for (DocumentModel doc : listeDocuments.values()) {
			if(doc.getIdentifiant().toLowerCase().contains(identifiant.toLowerCase())) tmp.add(doc);
		}
		return tmp;
	}
	
	public Collection<DocumentModel> rechercheDocuments(String id, String nom, String desc, String type, String date){
		List<DocumentModel> tmp = new ArrayList<DocumentModel>();
		for (DocumentModel doc : listeDocuments.values()) {
			if(doc.ressemble(id, nom, desc, type, date)) tmp.add(doc);
		}
		return tmp;
	}
	public Collection<ComboItem> getListeDocumentsCombo(){
		List<ComboItem> tmp = new ArrayList<ComboItem>();
		for (DocumentModel doc : listeDocuments.values()) {
			tmp.add(new ComboItem(doc.getIdentifiant(), doc.getNom()));
		}
		return tmp;	
	}
	
	public String getDateDisponibilite(String id){
		for (PretModel p : listePrets.values()) {
			if(p.getIdentifiantDocument().equals(id) && p.getDateRetourEffectif().equals("")){
				return p.getDateRetourLimite();
			}
		}
		return "Indisponible";
	}
	
	/*Prets*/
	public Hashtable<String, PretModel> getListePrets(){
		return listePrets;
	}
	public void setListePrets(Hashtable<String, PretModel> prets){
		listePrets = prets;
	}
	
	public PretModel getPret(String identifiant) {
		return listePrets.get(identifiant);
	}
	public Collection<PretModel> getPrets() {
		return listePrets.values();
	}
	public void ajouterPret(String identifiant, PretModel pret) {
		if (!listePrets.containsKey(identifiant)) {
			listePrets.put(identifiant, pret);
			setChanged();
			notifyObservers(PRET);
		}
	}
	public void supprimerPret(String identifiant) {
		if (listePrets.containsKey(identifiant)) {
			listePrets.remove(identifiant);
			setChanged();
			notifyObservers(PRET);
		}
	}
	public Collection<PretModel> getListePretsParEmprunteur(String id){
		List<PretModel> tmp = new ArrayList<PretModel>();
		for (PretModel p : listePrets.values()) {
			if(p.getIdentifiantEmprunteur().equals(id)) tmp.add(p);
		}
		return tmp;		
	}

	public int getNombrePretParEmprunteur(String identifiant) {
		int n = 0;
		for (PretModel p : listePrets.values()) {
			if(p.getIdentifiantEmprunteur().equals(identifiant)) n++;
		}
		return n;	
	}
	public int getNombrePretEnCoursParEmprunteur(String identifiant) {
		int n = 0;
		for (PretModel p : listePrets.values()) {
			if(p.getIdentifiantEmprunteur().equals(identifiant) && !p.estTermine()) n++;
		}
		return n;	
	}
	
	
	/*Gestionnaires*/
	public Hashtable<String, GestionnaireModel> getListeGestionnaires(){
		return listeGestionnaires;
	}
	public void setListeGestionnaires(Hashtable<String, GestionnaireModel> gest){
		listeGestionnaires = gest;
	}
	
	public GestionnaireModel getGestionnaire(String identifiant) {
		return listeGestionnaires.get(identifiant);
	}
	
	public Collection<GestionnaireModel> getGestionnaires() {
		return listeGestionnaires.values();
	}
	
	public void ajouterGestionnaire(String identifiant, GestionnaireModel ges) {
		if (!listeGestionnaires.containsKey(identifiant)) {
			listeGestionnaires.put(identifiant, ges);
			setChanged();
			notifyObservers(GESTIONNAIRE);
		}
	}
	
	public void supprimerGestionnaire(String identifiant) {
		if (listeGestionnaires.containsKey(identifiant)) {
			listeGestionnaires.remove(identifiant);
			setChanged();
			notifyObservers(GESTIONNAIRE);
		}
	}
	
	public Collection<GestionnaireModel> getGestionnaireAvecNom(String text) {
		List<GestionnaireModel> tmp = new ArrayList<GestionnaireModel>();
		for (GestionnaireModel ges : listeGestionnaires.values()) {
			if(ges.getNom().toLowerCase().contains(text.toLowerCase())) tmp.add(ges);
		}
		return tmp;
	}
	public Collection<GestionnaireModel> rechercheGestionnaire(String login, String nom, String prenom, String email, String identifiant){
		List<GestionnaireModel> tmp = new ArrayList<GestionnaireModel>();
		for (GestionnaireModel ges : listeGestionnaires.values()) {
			if(ges.ressemble(login,nom,prenom,email,identifiant)) tmp.add(ges);
		}
		return tmp;
	}
	
	
	
	/*Emprunteurs*/
	
	public Hashtable<String, EmprunteurModel> getListeEmprunteurs(){
		return listeEmprunteurs;
	}
	public void setListeEmprunteurs(Hashtable<String, EmprunteurModel> emp){
		listeEmprunteurs = emp;
	}	
	public EmprunteurModel getEmprunteur(String identifiant) {
		return listeEmprunteurs.get(identifiant);
	}
	public Collection<EmprunteurModel> getEmprunteurs() {
		return listeEmprunteurs.values();
	}
	public void ajouterEmprunteur(String identifiant, EmprunteurModel emprunteur) {
		if (!listeEmprunteurs.containsKey(identifiant)) {
			listeEmprunteurs.put(identifiant, emprunteur);
			setChanged();
			notifyObservers(EMPRUNTEUR);
		}
	}
	public void supprimerEmprunteur(String identifiant) {
		if (listeEmprunteurs.containsKey(identifiant)) {
			listeEmprunteurs.remove(identifiant);
			setChanged();
			notifyObservers(EMPRUNTEUR);
		}
	}
	public boolean existePret(String identifiant_emprunteur) {
		Iterator<PretModel> it = listePrets.values().iterator();
		PretModel courant;
		while(it.hasNext()) {
			courant = it.next();
			if (courant.getIdentifiantEmprunteur().equals(identifiant_emprunteur)) return true;
		}
		return false;
	}
	public Collection<EmprunteurModel> rechercheEmprunteurs(String id,
			String nom, String prenom, String email, String adresse) {
		List<EmprunteurModel> tmp = new ArrayList<EmprunteurModel>();
		for (EmprunteurModel emp : listeEmprunteurs.values()) {
			if(emp.ressemble(id, nom, prenom, email, adresse)) tmp.add(emp);
		}
		return tmp;
	}

	
	public Collection<ComboItem> getListeEmprunteursCombo(){
		List<ComboItem> tmp = new ArrayList<ComboItem>();
		for (EmprunteurModel emp : listeEmprunteurs.values()) {
			tmp.add(new ComboItem(emp.getIdentifiant(), emp.getNom()+" "+emp.getPrenom()));
		}
		return tmp;	
	}
	
	public boolean emprunteurAutoriseAEmprunter(String id){
		int nPretEnCours = 0;
		for (PretModel pret : listePrets.values()) {
			if(pret.getIdentifiantEmprunteur().equals(id) && !pret.estTermine()){
				nPretEnCours++;
			}
		}

		return nPretEnCours < 3;
	}
	
	
	public boolean documentAutoriseASupprimer(String s) {
		Iterator<PretModel> it = listePrets.values().iterator();
		PretModel courant;
		while (it.hasNext()) {
			courant = it.next();
			if (courant.getIdentifiantDocument().equals(s)) return false;
		}
		return true;
	}

	public void changementDocument() {
		setChanged();
		notifyObservers(DOCUMENT);
	}
	public void changementGestionnaire() {
		setChanged();
		notifyObservers(GESTIONNAIRE);
	}

	public Collection<PretModel> recherchePrets(String id, String emp, String doc, String dateE, String dateL) {
		List<PretModel> tmp = new ArrayList<PretModel>();
		for (PretModel pret : listePrets.values()) {
			if(getEmprunteur(pret.getIdentifiantEmprunteur()).ressemble(emp) &&
			   getDocument(pret.getIdentifiantDocument()).ressemble(doc) &&
			   pret.ressemble(id,dateE, dateL)){
				tmp.add(pret);
			}
		}
		return tmp;
	}

	public void changementEmprunteur() {
		// TODO Auto-generated method stub
		setChanged();
		notifyObservers(EMPRUNTEUR);
	}
	public void changementPret() {
		setChanged();
		notifyObservers(PRET);
	}




}
